ReactJS Ultra For Beginners

🔷 TypeScript in React


What is TypeScript in React?

  • Adds static type checking to React applications
  • Catches errors at compile time instead of runtime
  • Provides better IntelliSense and developer experience
  • Makes code more maintainable and self-documenting

📝 Basic Setup

// Component with TypeScript interface UserProps { name: string; age: number; email?: string; // Optional prop } function User({ name, age, email }: UserProps) { return ( <div> <h2>{name}</h2> <p>Age: {age}</p> {email && <p>Email: {email}</p>} </div> ); } // Usage <User name="John" age={25} email="john@example.com" />;

🔑 Core Concepts

1. Props Interface:

interface ButtonProps { text: string; onClick: () => void; variant?: "primary" | "secondary" | "danger"; disabled?: boolean; size?: "small" | "medium" | "large"; } function Button({ text, onClick, variant = "primary", disabled = false, size = "medium", }: ButtonProps) { return ( <button onClick={onClick} disabled={disabled} className={`btn btn-${variant} btn-${size}`} > {text} </button> ); }

2. State with TypeScript:

interface User { id: number; name: string; email: string; } function UserProfile() { const [user, setUser] = (useState < User) | (null > null); const [loading, setLoading] = useState < boolean > false; const [error, setError] = (useState < string) | (null > null); const fetchUser = async (id: number): Promise<void> => { setLoading(true); try { const response = await fetch(`/api/users/${id}`); const userData: User = await response.json(); setUser(userData); } catch (err) { setError(err instanceof Error ? err.message : "An error occurred"); } finally { setLoading(false); } }; return ( <div> {loading && <p>Loading...</p>} {error && <p>Error: {error}</p>} {user && ( <div> <h1>{user.name}</h1> <p>{user.email}</p> </div> )} </div> ); }

3. Event Handlers:

interface FormData { name: string; email: string; age: number; } function UserForm() { const [formData, setFormData] = useState < FormData > { name: "", email: "", age: 0, }; const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>): void => { const { name, value } = e.target; setFormData((prev) => ({ ...prev, [name]: name === "age" ? parseInt(value) || 0 : value, })); }; const handleSubmit = (e: React.FormEvent<HTMLFormElement>): void => { e.preventDefault(); console.log("Form submitted:", formData); }; return ( <form onSubmit={handleSubmit}> <input type="text" name="name" value={formData.name} onChange={handleInputChange} placeholder="Name" /> <input type="email" name="email" value={formData.email} onChange={handleInputChange} placeholder="Email" /> <input type="number" name="age" value={formData.age} onChange={handleInputChange} placeholder="Age" /> <button type="submit">Submit</button> </form> ); }

🎯 Common Patterns

Generic Components:

interface ListProps<T> { items: T[]; renderItem: (item: T, index: number) => React.ReactNode; keyExtractor: (item: T) => string | number; } function List<T>({ items, renderItem, keyExtractor }: ListProps<T>) { return ( <ul> {items.map((item, index) => ( <li key={keyExtractor(item)}>{renderItem(item, index)}</li> ))} </ul> ); } // Usage interface User { id: number; name: string; } function UserList() { const users: User[] = [ { id: 1, name: "John" }, { id: 2, name: "Jane" }, ]; return ( <List items={users} renderItem={(user) => <span>{user.name}</span>} keyExtractor={(user) => user.id} /> ); }

Custom Hooks with TypeScript:

interface UseCounterReturn { count: number; increment: () => void; decrement: () => void; reset: () => void; } function useCounter(initialValue: number = 0): UseCounterReturn { const [count, setCount] = useState < number > initialValue; const increment = (): void => setCount((prev) => prev + 1); const decrement = (): void => setCount((prev) => prev - 1); const reset = (): void => setCount(initialValue); return { count, increment, decrement, reset }; } // Usage function Counter() { const { count, increment, decrement, reset } = useCounter(10); return ( <div> <p>Count: {count}</p> <button onClick={increment}>+</button> <button onClick={decrement}>-</button> <button onClick={reset}>Reset</button> </div> ); }

Context with TypeScript:

interface ThemeContextType { theme: "light" | "dark"; toggleTheme: () => void; } const ThemeContext = (createContext < ThemeContextType) | (undefined > undefined); function ThemeProvider({ children }: { children: React.ReactNode }) { const [theme, setTheme] = (useState < "light") | ("dark" > "light"); const toggleTheme = (): void => { setTheme((prev) => (prev === "light" ? "dark" : "light")); }; return ( <ThemeContext.Provider value={{ theme, toggleTheme }}> {children} </ThemeContext.Provider> ); } function useTheme(): ThemeContextType { const context = useContext(ThemeContext); if (context === undefined) { throw new Error("useTheme must be used within a ThemeProvider"); } return context; }

🔧 Advanced Types

Union Types:

type Status = "idle" | "loading" | "success" | "error"; interface ApiState<T> { data: T | null; status: Status; error: string | null; } function useApi<T>(url: string): ApiState<T> { const [state, setState] = useState < ApiState < T >> { data: null, status: "idle", error: null, }; // ... implementation return state; }

Utility Types:

interface User { id: number; name: string; email: string; age: number; } // Make all properties optional type PartialUser = Partial<User>; // Make specific properties required type CreateUser = Pick<User, "name" | "email"> & Partial<Pick<User, "age">>; // Omit specific properties type UserWithoutId = Omit<User, "id">; // Function type type EventHandler<T = HTMLElement> = (event: React.MouseEvent<T>) => void;

Conditional Types:

type ButtonProps<T extends 'button' | 'a'> = { as?: T; children: React.ReactNode; } & (T extends 'button' ? React.ButtonHTMLAttributes<HTMLButtonElement> : React.AnchorHTMLAttributes<HTMLAnchorElement> ); function Button<T extends 'button' | 'a' = 'button'>({ as, children, ...props }: ButtonProps<T>) { const Component = as || 'button'; return <Component {...props}>{children}</Component>; }

⚠️ Best Practices

  1. Use interfaces for object shapes - more extensible than types
  2. Use type for unions and primitives - more appropriate
  3. Always type your props - even for simple components
  4. Use generic constraints - limit what types can be passed
  5. Handle undefined/null properly - use optional chaining and nullish coalescing
  6. Use strict mode - enable strict TypeScript configuration
  7. Avoid any type - use unknown or proper types instead

🔧 Configuration

tsconfig.json:

{ "compilerOptions": { "target": "ES2020", "lib": ["DOM", "DOM.Iterable", "ES6"], "allowJs": true, "skipLibCheck": true, "esModuleInterop": true, "allowSyntheticDefaultImports": true, "strict": true, "forceConsistentCasingInFileNames": true, "noFallthroughCasesInSwitch": true, "module": "ESNext", "moduleResolution": "node", "resolveJsonModule": true, "isolatedModules": true, "noEmit": true, "jsx": "react-jsx" }, "include": ["src"] }